home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / sre_compile.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-29  |  11.2 KB  |  562 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. from sre_constants import *
  8. if not _sre.MAGIC == MAGIC:
  9.     raise AssertionError, 'SRE module mismatch'
  10. if _sre.CODESIZE == 2:
  11.     MAXCODE = 65535
  12. else:
  13.     MAXCODE = 0xFFFFFFFFL
  14.  
  15. def _identityfunction(x):
  16.     return x
  17.  
  18.  
  19. def set(seq):
  20.     s = { }
  21.     for elem in seq:
  22.         s[elem] = 1
  23.     
  24.     return s
  25.  
  26. _LITERAL_CODES = set([
  27.     LITERAL,
  28.     NOT_LITERAL])
  29. _REPEATING_CODES = set([
  30.     REPEAT,
  31.     MIN_REPEAT,
  32.     MAX_REPEAT])
  33. _SUCCESS_CODES = set([
  34.     SUCCESS,
  35.     FAILURE])
  36. _ASSERT_CODES = set([
  37.     ASSERT,
  38.     ASSERT_NOT])
  39.  
  40. def _compile(code, pattern, flags):
  41.     emit = code.append
  42.     _len = len
  43.     LITERAL_CODES = _LITERAL_CODES
  44.     REPEATING_CODES = _REPEATING_CODES
  45.     SUCCESS_CODES = _SUCCESS_CODES
  46.     ASSERT_CODES = _ASSERT_CODES
  47.     for op, av in pattern:
  48.         if op in LITERAL_CODES:
  49.             if flags & SRE_FLAG_IGNORECASE:
  50.                 emit(OPCODES[OP_IGNORE[op]])
  51.                 emit(_sre.getlower(av, flags))
  52.             else:
  53.                 emit(OPCODES[op])
  54.                 emit(av)
  55.         flags & SRE_FLAG_IGNORECASE
  56.         if op is IN:
  57.             if flags & SRE_FLAG_IGNORECASE:
  58.                 emit(OPCODES[OP_IGNORE[op]])
  59.                 
  60.                 def fixup(literal, flags = flags):
  61.                     return _sre.getlower(literal, flags)
  62.  
  63.             else:
  64.                 emit(OPCODES[op])
  65.                 fixup = _identityfunction
  66.             skip = _len(code)
  67.             emit(0)
  68.             _compile_charset(av, flags, code, fixup)
  69.             code[skip] = _len(code) - skip
  70.             continue
  71.         if op is ANY:
  72.             if flags & SRE_FLAG_DOTALL:
  73.                 emit(OPCODES[ANY_ALL])
  74.             else:
  75.                 emit(OPCODES[ANY])
  76.         flags & SRE_FLAG_DOTALL
  77.         if op in REPEATING_CODES:
  78.             if flags & SRE_FLAG_TEMPLATE:
  79.                 raise error, 'internal: unsupported template operator'
  80.                 emit(OPCODES[REPEAT])
  81.                 skip = _len(code)
  82.                 emit(0)
  83.                 emit(av[0])
  84.                 emit(av[1])
  85.                 _compile(code, av[2], flags)
  86.                 emit(OPCODES[SUCCESS])
  87.                 code[skip] = _len(code) - skip
  88.             elif _simple(av) and op is not REPEAT:
  89.                 if op is MAX_REPEAT:
  90.                     emit(OPCODES[REPEAT_ONE])
  91.                 else:
  92.                     emit(OPCODES[MIN_REPEAT_ONE])
  93.                 skip = _len(code)
  94.                 emit(0)
  95.                 emit(av[0])
  96.                 emit(av[1])
  97.                 _compile(code, av[2], flags)
  98.                 emit(OPCODES[SUCCESS])
  99.                 code[skip] = _len(code) - skip
  100.             else:
  101.                 emit(OPCODES[REPEAT])
  102.                 skip = _len(code)
  103.                 emit(0)
  104.                 emit(av[0])
  105.                 emit(av[1])
  106.                 _compile(code, av[2], flags)
  107.                 code[skip] = _len(code) - skip
  108.                 if op is MAX_REPEAT:
  109.                     emit(OPCODES[MAX_UNTIL])
  110.                 else:
  111.                     emit(OPCODES[MIN_UNTIL])
  112.         op is MAX_REPEAT
  113.         if op is SUBPATTERN:
  114.             if av[0]:
  115.                 emit(OPCODES[MARK])
  116.                 emit((av[0] - 1) * 2)
  117.             
  118.             _compile(code, av[1], flags)
  119.             if av[0]:
  120.                 emit(OPCODES[MARK])
  121.                 emit((av[0] - 1) * 2 + 1)
  122.             
  123.         av[0]
  124.         if op in SUCCESS_CODES:
  125.             emit(OPCODES[op])
  126.             continue
  127.         if op in ASSERT_CODES:
  128.             emit(OPCODES[op])
  129.             skip = _len(code)
  130.             emit(0)
  131.             if av[0] >= 0:
  132.                 emit(0)
  133.             else:
  134.                 (lo, hi) = av[1].getwidth()
  135.                 if lo != hi:
  136.                     raise error, 'look-behind requires fixed-width pattern'
  137.                 
  138.                 emit(lo)
  139.             _compile(code, av[1], flags)
  140.             emit(OPCODES[SUCCESS])
  141.             code[skip] = _len(code) - skip
  142.             continue
  143.         if op is CALL:
  144.             emit(OPCODES[op])
  145.             skip = _len(code)
  146.             emit(0)
  147.             _compile(code, av, flags)
  148.             emit(OPCODES[SUCCESS])
  149.             code[skip] = _len(code) - skip
  150.             continue
  151.         if op is AT:
  152.             emit(OPCODES[op])
  153.             if flags & SRE_FLAG_MULTILINE:
  154.                 av = AT_MULTILINE.get(av, av)
  155.             
  156.             if flags & SRE_FLAG_LOCALE:
  157.                 av = AT_LOCALE.get(av, av)
  158.             elif flags & SRE_FLAG_UNICODE:
  159.                 av = AT_UNICODE.get(av, av)
  160.             
  161.             emit(ATCODES[av])
  162.             continue
  163.         if op is BRANCH:
  164.             emit(OPCODES[op])
  165.             tail = []
  166.             tailappend = tail.append
  167.             for av in av[1]:
  168.                 skip = _len(code)
  169.                 emit(0)
  170.                 _compile(code, av, flags)
  171.                 emit(OPCODES[JUMP])
  172.                 tailappend(_len(code))
  173.                 emit(0)
  174.                 code[skip] = _len(code) - skip
  175.             
  176.             emit(0)
  177.             for tail in tail:
  178.                 code[tail] = _len(code) - tail
  179.             
  180.         if op is CATEGORY:
  181.             emit(OPCODES[op])
  182.             if flags & SRE_FLAG_LOCALE:
  183.                 av = CH_LOCALE[av]
  184.             elif flags & SRE_FLAG_UNICODE:
  185.                 av = CH_UNICODE[av]
  186.             
  187.             emit(CHCODES[av])
  188.             continue
  189.         if op is GROUPREF:
  190.             if flags & SRE_FLAG_IGNORECASE:
  191.                 emit(OPCODES[OP_IGNORE[op]])
  192.             else:
  193.                 emit(OPCODES[op])
  194.             emit(av - 1)
  195.             continue
  196.         if op is GROUPREF_EXISTS:
  197.             emit(OPCODES[op])
  198.             emit(av[0] - 1)
  199.             skipyes = _len(code)
  200.             emit(0)
  201.             _compile(code, av[1], flags)
  202.             if av[2]:
  203.                 emit(OPCODES[JUMP])
  204.                 skipno = _len(code)
  205.                 emit(0)
  206.                 code[skipyes] = (_len(code) - skipyes) + 1
  207.                 _compile(code, av[2], flags)
  208.                 code[skipno] = _len(code) - skipno
  209.             else:
  210.                 code[skipyes] = (_len(code) - skipyes) + 1
  211.         av[2]
  212.         raise ValueError, ('unsupported operand type', op)
  213.     
  214.  
  215.  
  216. def _compile_charset(charset, flags, code, fixup = None):
  217.     emit = code.append
  218.     if fixup is None:
  219.         fixup = _identityfunction
  220.     
  221.     for op, av in _optimize_charset(charset, fixup):
  222.         emit(OPCODES[op])
  223.         if op is NEGATE:
  224.             continue
  225.         if op is LITERAL:
  226.             emit(fixup(av))
  227.             continue
  228.         if op is RANGE:
  229.             emit(fixup(av[0]))
  230.             emit(fixup(av[1]))
  231.             continue
  232.         if op is CHARSET:
  233.             code.extend(av)
  234.             continue
  235.         if op is BIGCHARSET:
  236.             code.extend(av)
  237.             continue
  238.         if op is CATEGORY:
  239.             if flags & SRE_FLAG_LOCALE:
  240.                 emit(CHCODES[CH_LOCALE[av]])
  241.             elif flags & SRE_FLAG_UNICODE:
  242.                 emit(CHCODES[CH_UNICODE[av]])
  243.             else:
  244.                 emit(CHCODES[av])
  245.         flags & SRE_FLAG_LOCALE
  246.         raise error, 'internal: unsupported set operator'
  247.     
  248.     emit(OPCODES[FAILURE])
  249.  
  250.  
  251. def _optimize_charset(charset, fixup):
  252.     out = []
  253.     outappend = out.append
  254.     charmap = [
  255.         0] * 256
  256.     
  257.     try:
  258.         for op, av in charset:
  259.             if op is NEGATE:
  260.                 outappend((op, av))
  261.                 continue
  262.             if op is LITERAL:
  263.                 charmap[fixup(av)] = 1
  264.                 continue
  265.             if op is RANGE:
  266.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  267.                     charmap[i] = 1
  268.                 
  269.             if op is CATEGORY:
  270.                 return charset
  271.                 continue
  272.     except IndexError:
  273.         return _optimize_unicode(charset, fixup)
  274.  
  275.     i = p = n = 0
  276.     runs = []
  277.     runsappend = runs.append
  278.     for c in charmap:
  279.         if c:
  280.             if n == 0:
  281.                 p = i
  282.             
  283.             n = n + 1
  284.         elif n:
  285.             runsappend((p, n))
  286.             n = 0
  287.         
  288.         i = i + 1
  289.     
  290.     if n:
  291.         runsappend((p, n))
  292.     
  293.     if len(runs) <= 2:
  294.         for p, n in runs:
  295.             if n == 1:
  296.                 outappend((LITERAL, p))
  297.                 continue
  298.             outappend((RANGE, (p, p + n - 1)))
  299.         
  300.         if len(out) < len(charset):
  301.             return out
  302.         
  303.     else:
  304.         data = _mk_bitmap(charmap)
  305.         outappend((CHARSET, data))
  306.         return out
  307.     return charset
  308.  
  309.  
  310. def _mk_bitmap(bits):
  311.     data = []
  312.     dataappend = data.append
  313.     if _sre.CODESIZE == 2:
  314.         start = (1, 0)
  315.     else:
  316.         start = (0x1L, 0x0L)
  317.     (m, v) = start
  318.     for c in bits:
  319.         if c:
  320.             v = v + m
  321.         
  322.         m = m + m
  323.         if m > MAXCODE:
  324.             dataappend(v)
  325.             (m, v) = start
  326.             continue
  327.     
  328.     return data
  329.  
  330.  
  331. def _optimize_unicode(charset, fixup):
  332.     
  333.     try:
  334.         import array
  335.     except ImportError:
  336.         return charset
  337.  
  338.     charmap = [
  339.         0] * 65536
  340.     negate = 0
  341.     
  342.     try:
  343.         for op, av in charset:
  344.             if op is NEGATE:
  345.                 negate = 1
  346.                 continue
  347.             if op is LITERAL:
  348.                 charmap[fixup(av)] = 1
  349.                 continue
  350.             if op is RANGE:
  351.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  352.                     charmap[i] = 1
  353.                 
  354.             if op is CATEGORY:
  355.                 return charset
  356.                 continue
  357.     except IndexError:
  358.         return charset
  359.  
  360.     if negate:
  361.         if sys.maxunicode != 65535:
  362.             return charset
  363.         
  364.         for i in xrange(65536):
  365.             charmap[i] = not charmap[i]
  366.         
  367.     
  368.     comps = { }
  369.     mapping = [
  370.         0] * 256
  371.     block = 0
  372.     data = []
  373.     for i in xrange(256):
  374.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  375.         new = comps.setdefault(chunk, block)
  376.         mapping[i] = new
  377.         if new == block:
  378.             block = block + 1
  379.             data = data + _mk_bitmap(chunk)
  380.             continue
  381.     
  382.     header = [
  383.         block]
  384.     if _sre.CODESIZE == 2:
  385.         code = 'H'
  386.     else:
  387.         code = 'I'
  388.     mapping = array.array('b', mapping).tostring()
  389.     mapping = array.array(code, mapping)
  390.     if not mapping.itemsize == _sre.CODESIZE:
  391.         raise AssertionError
  392.     header = header + mapping.tolist()
  393.     data[0:0] = header
  394.     return [
  395.         (BIGCHARSET, data)]
  396.  
  397.  
  398. def _simple(av):
  399.     (lo, hi) = av[2].getwidth()
  400.     if lo == 0 and hi == MAXREPEAT:
  401.         raise error, 'nothing to repeat'
  402.     
  403.     if hi == hi:
  404.         pass
  405.     elif hi == 1:
  406.         pass
  407.     return av[2][0][0] != SUBPATTERN
  408.  
  409.  
  410. def _compile_info(code, pattern, flags):
  411.     (lo, hi) = pattern.getwidth()
  412.     if lo == 0:
  413.         return None
  414.     
  415.     prefix = []
  416.     prefixappend = prefix.append
  417.     prefix_skip = 0
  418.     charset = []
  419.     charsetappend = charset.append
  420.     if not flags & SRE_FLAG_IGNORECASE:
  421.         for op, av in pattern.data:
  422.             if op is LITERAL:
  423.                 if len(prefix) == prefix_skip:
  424.                     prefix_skip = prefix_skip + 1
  425.                 
  426.                 prefixappend(av)
  427.                 continue
  428.             if op is SUBPATTERN and len(av[1]) == 1:
  429.                 (op, av) = av[1][0]
  430.                 if op is LITERAL:
  431.                     prefixappend(av)
  432.                 else:
  433.                     break
  434.             op is LITERAL
  435.         
  436.         if not prefix and pattern.data:
  437.             (op, av) = pattern.data[0]
  438.             if op is SUBPATTERN and av[1]:
  439.                 (op, av) = av[1][0]
  440.                 if op is LITERAL:
  441.                     charsetappend((op, av))
  442.                 elif op is BRANCH:
  443.                     c = []
  444.                     cappend = c.append
  445.                     for p in av[1]:
  446.                         if not p:
  447.                             break
  448.                         
  449.                         (op, av) = p[0]
  450.                         if op is LITERAL:
  451.                             cappend((op, av))
  452.                             continue
  453.                     else:
  454.                         charset = c
  455.                 
  456.             elif op is BRANCH:
  457.                 c = []
  458.                 cappend = c.append
  459.                 for p in av[1]:
  460.                     if not p:
  461.                         break
  462.                     
  463.                     (op, av) = p[0]
  464.                     if op is LITERAL:
  465.                         cappend((op, av))
  466.                         continue
  467.                 else:
  468.                     charset = c
  469.             elif op is IN:
  470.                 charset = av
  471.             
  472.         
  473.     
  474.     emit = code.append
  475.     emit(OPCODES[INFO])
  476.     skip = len(code)
  477.     emit(0)
  478.     mask = 0
  479.     if prefix:
  480.         mask = SRE_INFO_PREFIX
  481.         if prefix_skip == prefix_skip:
  482.             pass
  483.         elif prefix_skip == len(pattern.data):
  484.             mask = mask + SRE_INFO_LITERAL
  485.         
  486.     elif charset:
  487.         mask = mask + SRE_INFO_CHARSET
  488.     
  489.     emit(mask)
  490.     if lo < MAXCODE:
  491.         emit(lo)
  492.     else:
  493.         emit(MAXCODE)
  494.         prefix = prefix[:MAXCODE]
  495.     if hi < MAXCODE:
  496.         emit(hi)
  497.     else:
  498.         emit(0)
  499.     if prefix:
  500.         emit(len(prefix))
  501.         emit(prefix_skip)
  502.         code.extend(prefix)
  503.         table = [
  504.             -1] + [
  505.             0] * len(prefix)
  506.         for i in xrange(len(prefix)):
  507.             table[i + 1] = table[i] + 1
  508.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  509.                 table[i + 1] = table[table[i + 1] - 1] + 1
  510.         
  511.         code.extend(table[1:])
  512.     elif charset:
  513.         _compile_charset(charset, flags, code)
  514.     
  515.     code[skip] = len(code) - skip
  516.  
  517.  
  518. try:
  519.     unicode
  520. except NameError:
  521.     STRING_TYPES = (type(''),)
  522.  
  523. STRING_TYPES = (type(''), type(unicode('')))
  524.  
  525. def isstring(obj):
  526.     for tp in STRING_TYPES:
  527.         if isinstance(obj, tp):
  528.             return 1
  529.             continue
  530.     
  531.     return 0
  532.  
  533.  
  534. def _code(p, flags):
  535.     flags = p.pattern.flags | flags
  536.     code = []
  537.     _compile_info(code, p, flags)
  538.     _compile(code, p.data, flags)
  539.     code.append(OPCODES[SUCCESS])
  540.     return code
  541.  
  542.  
  543. def compile(p, flags = 0):
  544.     if isstring(p):
  545.         import sre_parse
  546.         pattern = p
  547.         p = sre_parse.parse(p, flags)
  548.     else:
  549.         pattern = None
  550.     code = _code(p, flags)
  551.     if p.pattern.groups > 100:
  552.         raise AssertionError('sorry, but this version only supports 100 named groups')
  553.     
  554.     groupindex = p.pattern.groupdict
  555.     indexgroup = [
  556.         None] * p.pattern.groups
  557.     for k, i in groupindex.items():
  558.         indexgroup[i] = k
  559.     
  560.     return _sre.compile(pattern, flags | p.pattern.flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  561.  
  562.